"""
模块名称：example_pm.py
作者：Lionel.Zhang
创建时间：2025 - 11 - 05
最后修改时间：2025 - 11 - 05
功能描述：pm 低功耗示例程序
"""

import pm
import utime
import sys

class PowerManager:
    """
    电源管理类，用于管理wakelock和系统休眠
    """
    
    def __init__(self, lock_name="power_lock"):
        self.lock_name = lock_name
        self.lock_fd = None
        self.is_locked = False
        self.operation_count = 0
        self.initialize_power_management()
    
    def initialize_power_management(self):
        """初始化电源管理设置"""
        try:
            print("=== 电源管理系统初始化 ===")
            print("锁名称: {}".format(self.lock_name))
            
            # 创建wakelock
            self.lock_fd = pm.create_wakelock(self.lock_name, len(self.lock_name))
            if self.lock_fd is None or self.lock_fd < 0:
                raise Exception("创建wakelock失败")
                
            print("✓ Wakelock创建成功, fd = {}".format(self.lock_fd))
            
            # 设置自动休眠模式
            pm.autosleep(1)
            print("✓ 自动休眠模式已启用")
            
            # 显示初始状态
            self.show_system_status()
            
        except Exception as e:
            print("✗ 电源管理初始化失败: {}".format(e))
            sys.exit()
    
    def lock_wakelock(self):
        """锁定wakelock，阻止系统休眠"""
        try:
            self.operation_count += 1
            print("\n--- 操作 #{}: 锁定wakelock ---".format(self.operation_count))
            print("当前时间: {}".format(utime.time()))
            
            result = pm.wakelock_lock(self.lock_fd)
            if result != 0:
                raise Exception("锁定操作失败，返回码: {}".format(result))
                
            self.is_locked = True
            print("✓ Wakelock锁定成功")
            print("锁描述符: {}".format(self.lock_fd))
            
            return True
            
        except Exception as e:
            print("✗ Wakelock锁定失败: {}".format(e))
            return False
    
    def unlock_wakelock(self):
        """解锁wakelock，允许系统休眠"""
        try:
            self.operation_count += 1
            print("\n--- 操作 #{}: 解锁wakelock ---".format(self.operation_count))
            print("当前时间: {}".format(utime.time()))
            
            result = pm.wakelock_unlock(self.lock_fd)
            if result != 0:
                raise Exception("解锁操作失败，返回码: {}".format(result))
                
            self.is_locked = False
            print("✓ Wakelock解锁成功")
            print("锁描述符: {}".format(self.lock_fd))
            
            return True
            
        except Exception as e:
            print("✗ Wakelock解锁失败: {}".format(e))
            return False
    
    def get_wakelock_count(self):
        """获取当前wakelock数量"""
        try:
            count = pm.get_wakelock_num()
            return count
        except Exception as e:
            print("获取wakelock数量失败: {}".format(e))
            return -1
    
    def show_system_status(self):
        """显示系统当前状态"""
        print("\n[系统状态报告]")
        print("当前时间戳: {}".format(utime.time()))
        print("Wakelock状态: {}".format("已锁定" if self.is_locked else "未锁定"))
        print("Wakelock描述符: {}".format(self.lock_fd))
        print("活跃wakelock数量: {}".format(self.get_wakelock_count()))
        print("总操作次数: {}".format(self.operation_count))
        print("-" * 40)
    
    def timed_operation(self, lock_duration=20, unlock_duration=20, cycles=5):
        """
        执行定时锁定/解锁操作
        
        Args:
            lock_duration: 锁定持续时间(秒)
            unlock_duration: 解锁持续时间(秒)
            cycles: 循环次数
        """
        print("\n=== 开始定时功耗管理测试 ===")
        print("测试参数: 锁定{}秒, 解锁{}秒, 共{}个循环".format(
            lock_duration, unlock_duration, cycles))
        
        for cycle in range(1, cycles + 1):
            print("\n" + "="*50)
            print("循环 {}/{}".format(cycle, cycles))
            print("="*50)
            
            # 解锁阶段 - 允许系统休眠
            print("\n[阶段1: 解锁 - 允许休眠]")
            if self.unlock_wakelock():
                print("等待 {} 秒...".format(unlock_duration))
                for sec in range(unlock_duration):
                    utime.sleep(1)
                    if sec % 5 == 0:  # 每5秒打印一次进度
                        print("  已等待 {} 秒".format(sec + 1))
            
            # 锁定阶段 - 阻止系统休眠
            print("\n[阶段2: 锁定 - 阻止休眠]")
            if self.lock_wakelock():
                print("保持唤醒 {} 秒...".format(lock_duration))
                for sec in range(lock_duration):
                    utime.sleep(1)
                    if sec % 5 == 0:  # 每5秒打印一次进度
                        print("  已保持唤醒 {} 秒".format(sec + 1))
            
            # 显示当前状态
            self.show_system_status()
        
        print("\n=== 定时功耗管理测试完成 ===")
    
    def cleanup(self):
        """清理资源"""
        print("\n=== 清理电源管理资源 ===")
        if self.is_locked:
            self.unlock_wakelock()
        print("✓ 资源清理完成")


def main():
    """
    主函数 - 程序入口
    """
    print("电源管理演示程序启动")
    start_time = utime.time()
    
    # 创建电源管理器实例
    power_mgr = PowerManager("precision_power_lock")
    
    try:
        # 执行定时测试
        power_mgr.timed_operation(
            lock_duration=15,      # 锁定15秒
            unlock_duration=10,    # 解锁10秒  
            cycles=3               # 3个循环
        )
        
        # 最终状态报告
        print("\n" + "="*60)
        print("最终状态报告")
        print("="*60)
        power_mgr.show_system_status()
        
        # 计算运行时间
        end_time = utime.time()
        total_time = end_time - start_time
        print("程序总运行时间: {:.2f} 秒".format(total_time))
        
    except KeyboardInterrupt:
        print("\n程序被用户中断")
    except Exception as e:
        print("\n程序执行出错: {}".format(e))
    finally:
        # 确保资源被清理
        power_mgr.cleanup()
        print("程序结束")


# 程序入口点
if __name__ == "__main__":
    main()